Aller au contenu principal

Commandes de base

Git est un système de contrôle de version distribué, créé par Linus Torvalds en 2005 pour gérer le développement du noyau Linux. Il permet de suivre les modifications apportées aux fichiers et de collaborer efficacement sur des projets.

Création d'un compte GitLab​

Commencez par créer un compte sur GitLab. J'ai choisi GitLab car il facilite la gestion de dépôts privés.

Repository​

Créez ensuite un dépôt (repository), c'est-à-dire un ensemble organisé de répertoires et de fichiers liés à un projet.

Il peut correspondre à un unique projet open source, par exemple :

https://github.com/home-assistant/core

Ou regrouper plusieurs projets, comme mon dépôt destiné à centraliser mes notes de cours :

https://gitlab.com/drynish/ecole

Accès​

Vous avez deux choix pour vous connecter à distance :

  • Mot de passe (déconseillé)
  • Paire de clés (privée/publique)

Génération de clé privée​

ssh-keygen

Par défaut, les clés sont générées dans le répertoire :

  • Windows : C:\Users\VotreNom\.ssh
  • macOS/Linux : ~/.ssh

Copiez la clé publique sur GitLab dans votre profil, section SSH Keys.

Vous pourrez vous authentifier sans retaper votre mot de passe.

Gardez votre clé privée avec vous (ou générez-en une nouvelle pour chaque machine et ajoutez-la à votre compte).

Je conserve personnellement la même clé sur mes différents postes.

git clone​

git clone git@gitlab.com/drynish/ecole

Crée une copie du dépôt ecole dans le répertoire courant.

Vous pouvez cloner le dépôt que vous avez créé précédemment.

git init​

Initialise un dépôt Git dans le dossier courant (crée le sous-dossier .git). À utiliser si vous partez d'un dossier existant sans contrôle de version.

git init

Ajoutez ensuite un dépôt distant si nécessaire :

git remote add origin git@gitlab.com:votre-compte/votre-depot.git

git rm​

Supprime un fichier du suivi Git et du disque.

git rm chemin/fichier

Pour arrêter de suivre un fichier tout en le conservant sur le disque (souvent après ajout au .gitignore) :

git rm --cached chemin/fichier

git mv​

Renomme ou déplace un fichier/dossier en gardant l'historique.

git mv src/MonFichier.java src/archive/MonFichier.java

git status​

Affiche l'état actuel de votre répertoire de travail et de la zone de staging. C'est la commande la plus utilisée en Git!

git status

Cette commande affiche :

  • Les fichiers modifiés qui ne sont pas encore ajoutés (en rouge)
  • Les fichiers ajoutés prêts à être commités (en vert)
  • Les fichiers non suivis par Git
  • La branche actuelle

Exemple de sortie :

On branch main
Changes not staged for commit:
  modified:   Main.java

Untracked files:
  .idea/
  out/

Conseil : Utilisez git status fréquemment pour savoir où vous en êtes!

.gitignore​

Le fichier .gitignore permet de spécifier quels fichiers ou dossiers Git doit ignorer et ne pas suivre. C'est essentiel pour éviter de valider des fichiers inutiles ou sensibles.

Créez un fichier .gitignore à la racine de votre projet :

# Fichiers compilés Java
*.class
*.jar
*.war

# Dossiers de build
out/
target/
build/

# Fichiers IDE (IntelliJ IDEA)
.idea/
*.iml

# Fichiers IDE (Eclipse)
.classpath
.project
.settings/

# Fichiers IDE (VS Code)
.vscode/

# Fichiers système
.DS_Store
Thumbs.db

# Logs
*.log

# Fichiers temporaires
*.tmp
*.swp
*~

Important : Créez votre .gitignore avant de faire votre premier commit!

Si vous avez déjà validé des fichiers à ignorer :

git rm -r --cached .idea/
git commit -m "Retirer .idea/ du suivi Git"

.git/config​

Ce fichier (dans le dossier caché .git/ à la racine du projet) contient la configuration locale du dépôt : nom distant, branche par défaut, utilisateur local, etc. Il est créé automatiquement lors du git init ou du git clone.

Pour le consulter :

cat .git/config

Exemple minimal :

[core]
  repositoryformatversion = 0
  filemode = true
  bare = false
  logallrefupdates = true
[remote "origin"]
  url = git@gitlab.com:drynish/ecole.git
  fetch = +refs/heads/*:refs/remotes/origin/*
[branch "main"]
  remote = origin
  merge = refs/heads/main

Ne versionnez jamais .git/config (il reste dans .git/ qui n'est pas suivi). Si vous changez l'URL ou la branche par défaut, cela n'affecte que votre clone local.

Scopes global / local / system​

Git applique la configuration par ordre de priorité (du plus spécifique au plus général) :

  1. Local (par dépôt) : .git/config — spécifique au projet courant. Commande :
git config --local user.name "Votre Nom"
  1. Global (pour l'utilisateur) : ~/.gitconfig — s'applique à tous vos dépôts. Commande :
git config --global user.email "vous@example.com"
  1. System (système) : /etc/gitconfig (ou équivalent) — configuration système partagée. Rarement modifié.

Priorité : Local > Global > System. Si une clé existe aux trois niveaux, la valeur locale gagne.

Pour lister :

git config --list --show-scope

git remote / origin​

  • Lister les remotes configurées :
git remote -v
  • Ajouter un remote nommé origin (cas d'un dépôt créé vide sur GitLab/GitHub, puis cloné localement) :
git remote add origin git@gitlab.com:votre-compte/votre-depot.git
  • Mettre à jour l'URL d'un remote existant (par exemple après migration HTTPS → SSH) :
git remote set-url origin git@gitlab.com:votre-compte/votre-depot.git
  • Vérifier les remotes après modification :
git remote -v

Bonnes pratiques :

  • Ne multipliez pas les remotes inutilement : origin suffit dans la majorité des cas.
  • Préférez SSH aux URLs HTTPS pour éviter de ressaisir vos identifiants.
  • Si vous forkez un projet : conservez origin pour votre fork et ajoutez upstream vers le dépôt source.

.empty​

Git ignore par défaut les dossiers vides. Pour forcer le suivi d'un dossier (par exemple data/, docs/), on place souvent un petit fichier marqueur, typiquement .empty ou .keep.

  • Créez un fichier vide dossier/.empty pour que Git conserve le dossier.
  • Documentez dans le README la raison de ce dossier si besoin (par exemple un répertoire où seront générés des fichiers à l'exécution).

Ne mettez pas de données réelles dans ces fichiers, ils servent uniquement de placeholder.

git add​

Ajoute des fichiers ou dossiers à l'index (zone de staging).

git add nom_de_fichier
ou 
git add . (répertoire)

git commit​

  • Enregistre un instantané local du code. Vous pouvez revenir en arrière avec checkout ou revert.

  • Ne validez pas de code non fonctionnel.

  • Validez régulièrement (fin d'une méthode ou d'une fonctionnalité). Cela facilite le retour arrière en cas de bug.

git commit -am "Nom de la nouvelle version"

git push​

Envoie vos commits locaux vers le dépôt distant configuré (par défaut origin).

git push

git pull​

Récupère et fusionne les derniers commits du dépôt distant dans votre branche locale. Nécessite un dépôt distant configuré dans le répertoire courant.

git pull